#include "interface_display.h"

// 定义颜色主题
#define COLOR_PRIMARY lv_palette_main(LV_PALETTE_BLUE)
#define COLOR_SECONDARY lv_palette_main(LV_PALETTE_PURPLE)
#define COLOR_SUCCESS lv_palette_main(LV_PALETTE_GREEN)
#define COLOR_WARNING lv_palette_main(LV_PALETTE_ORANGE)
#define COLOR_DANGER lv_palette_main(LV_PALETTE_RED)
#define COLOR_BG lv_color_hex(0xF5F5F5)
#define COLOR_CARD_BG lv_color_white()

// 全局样式
static lv_style_t style_card;
static lv_style_t style_title;
static lv_style_t style_value;
static lv_style_t style_label;

// 全局UI对象指针（用于实时更新）
static lv_obj_t * total_spaces_label        = NULL;
static lv_obj_t * available_spaces_label    = NULL;
static lv_obj_t * vehicles_in_label         = NULL;
static lv_obj_t * vehicles_out_label        = NULL;
static lv_obj_t * temperature_label         = NULL;
static lv_obj_t * humidity_label            = NULL;
static lv_obj_t * recognized_vehicles_label = NULL;
static lv_obj_t * unrecognized_rate_label   = NULL;
// 进度条指针
static lv_obj_t * floor_b1_bar           = NULL;
static lv_obj_t * floor_b2_bar           = NULL;
static lv_obj_t * floor_b3_bar           = NULL;
static lv_obj_t * floor_b1_label         = NULL;
static lv_obj_t * floor_b2_label         = NULL;
static lv_obj_t * floor_b3_label         = NULL;
static lv_obj_t * floor_b1_percent_label = NULL;
static lv_obj_t * floor_b2_percent_label = NULL;
static lv_obj_t * floor_b3_percent_label = NULL;

// 圆弧图相关指针
static lv_obj_t * duration_arcs[4]   = {NULL}; // 停车时长分布的4个圆弧
static lv_obj_t * vehicle_arcs[3]    = {NULL}; // 车辆类型分布的3个圆弧
static lv_obj_t * duration_labels[4] = {NULL}; // 停车时长百分比标签
static lv_obj_t * vehicle_labels[3]  = {NULL}; // 车辆类型百分比标签

static lv_obj_t * hour_bars[8] = {NULL}; // 保存8个时段的柱状图对象

// 在全局变量部分添加评分标签指针
static lv_obj_t * facility_score_label     = NULL;
static lv_obj_t * service_score_label      = NULL;
static lv_obj_t * satisfaction_score_label = NULL;

// UI更新函数
// 修改update_ui_with_data函数，添加环境数据
void update_ui_with_data(parking_data_t * data)
{
    printf("=== UI UPDATE START ===\n");

    // 调试信息：检查标签指针状态
    // printf("DEBUG: Label pointers status:\n");
    // printf("  total_spaces_label: %p\n", (void *)total_spaces_label);
    // printf("  floor_b1_label: %p\n", (void *)floor_b1_label);
    // printf("  floor_b2_label: %p\n", (void *)floor_b2_label);
    // printf("  floor_b3_label: %p\n", (void *)floor_b3_label);
    // printf("  facility_score_label: %p\n", (void *)facility_score_label);
    // printf("  service_score_label: %p\n", (void *)service_score_label);
    // printf("  satisfaction_score_label: %p\n", (void *)satisfaction_score_label);
    // printf("Data: recognized=%d, unrecognized=%.1f%%\n", data->recognized_vehicles,
    //        data->unrecognized_rate_x100 / 100.0);
    // printf("Vehicle types: truck=%d, suv=%d, car=%d\n", data->vehicle_type_truck, data->vehicle_type_suv,
    //        data->vehicle_type_car);
    // printf("Parking duration: <1h=%d, 1-2h=%d, 2-4h=%d, >4h=%d\n", data->parking_time_less_1h,
    // data->parking_time_1_2h,
    //        data->parking_time_2_4h, data->parking_time_more_4h);
    // printf("Data: floor_b1=%d%%, floor_b2=%d%%, floor_b3=%d%%\n", data->floor_b1_utilization,
    //        data->floor_b2_utilization, data->floor_b3_utilization);
    // printf("Peak hours: 8h=%d, 18h=%d\n", data->hour_8_count, data->hour_18_count);

    // 基础停车数据
    if(total_spaces_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%d", data->total_spaces);
        lv_label_set_text(total_spaces_label, buffer);
        printf("UI: Updated total_spaces to: %s\n", buffer);
    }

    if(available_spaces_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%d", data->available_spaces);
        lv_label_set_text(available_spaces_label, buffer);
        printf("UI: Updated available_spaces to: %s\n", buffer);
    }

    if(vehicles_in_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%d", data->vehicles_in);
        lv_label_set_text(vehicles_in_label, buffer);
        printf("UI: Updated vehicles_in to: %s\n", buffer);
    }

    if(vehicles_out_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%d", data->vehicles_out);
        lv_label_set_text(vehicles_out_label, buffer);
        printf("UI: Updated vehicles_out to: %s\n", buffer);
    }

    // 环境数据
    if(temperature_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%d", data->temperature);
        lv_label_set_text(temperature_label, buffer);
        printf("UI: Updated temperature to: %s\n", buffer);
    }

    if(humidity_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%d%%", data->humidity);
        lv_label_set_text(humidity_label, buffer);
        printf("UI: Updated humidity to: %s\n", buffer);
    }

    // 更新地下楼层标签
    if(floor_b1_label) {
        char label_text[64];
        snprintf(label_text, sizeof(label_text), "地下1层 %d个", data->floor_b1_total);
        lv_label_set_text(floor_b1_label, label_text);
        printf("UI: Updated floor_b1_label to: %s\n", label_text);
    } else {
        printf("ERROR: floor_b1_label is NULL!\n");
    }

    if(floor_b2_label) {
        char label_text[64];
        snprintf(label_text, sizeof(label_text), "地下2层 %d个", data->floor_b2_total);
        lv_label_set_text(floor_b2_label, label_text);
        printf("UI: Updated floor_b2_label to: %s\n", label_text);
    } else {
        printf("ERROR: floor_b2_label is NULL!\n");
    }

    if(floor_b3_label) {
        char label_text[64];
        snprintf(label_text, sizeof(label_text), "地下3层 %d个", data->floor_b3_total);
        lv_label_set_text(floor_b3_label, label_text);
        printf("UI: Updated floor_b3_label to: %s\n", label_text);
    } else {
        printf("ERROR: floor_b3_label is NULL!\n");
    }

    // 更新进度条和百分比标签
    if(floor_b1_bar) {
        lv_bar_set_value(floor_b1_bar, data->floor_b1_utilization, LV_ANIM_ON);
        if(floor_b1_percent_label) {
            char percent_str[10];
            snprintf(percent_str, sizeof(percent_str), "%d%%", data->floor_b1_utilization);
            lv_label_set_text(floor_b1_percent_label, percent_str);
        }
        printf("UI: Updated floor_b1 progress bar to: %d%%\n", data->floor_b1_utilization);
    }

    if(floor_b2_bar) {
        lv_bar_set_value(floor_b2_bar, data->floor_b2_utilization, LV_ANIM_ON);
        if(floor_b2_percent_label) {
            char percent_str[10];
            snprintf(percent_str, sizeof(percent_str), "%d%%", data->floor_b2_utilization);
            lv_label_set_text(floor_b2_percent_label, percent_str);
        }
        printf("UI: Updated floor_b2 progress bar to: %d%%\n", data->floor_b2_utilization);
    }

    if(floor_b3_bar) {
        lv_bar_set_value(floor_b3_bar, data->floor_b3_utilization, LV_ANIM_ON);
        if(floor_b3_percent_label) {
            char percent_str[10];
            snprintf(percent_str, sizeof(percent_str), "%d%%", data->floor_b3_utilization);
            lv_label_set_text(floor_b3_percent_label, percent_str);
        }
        printf("UI: Updated floor_b3 progress bar to: %d%%\n", data->floor_b3_utilization);
    }

    if(recognized_vehicles_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%d", data->recognized_vehicles);
        lv_label_set_text(recognized_vehicles_label, buffer);
        printf("UI: Updated recognized_vehicles to: %s\n", buffer);
    }

    if(unrecognized_rate_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%.1f%%", data->unrecognized_rate_x100 / 100.0);
        lv_label_set_text(unrecognized_rate_label, buffer);
        printf("UI: Updated unrecognized_rate to: %s\n", buffer);
    }

    // 更新停车时长分布圆弧图和标签
    int duration_total =
        data->parking_time_less_1h + data->parking_time_1_2h + data->parking_time_2_4h + data->parking_time_more_4h;

    if(duration_total > 0) {
        int duration_values[] = {data->parking_time_less_1h, data->parking_time_1_2h, data->parking_time_2_4h,
                                 data->parking_time_more_4h};

        // 更新标签 - 删除重复的if条件
        for(int i = 0; i < 4; i++) {
            if(duration_labels[i]) {
                char percent_text[20];
                int percentage = (duration_values[i] * 100) / duration_total;
                snprintf(percent_text, sizeof(percent_text), "%d%%", percentage);
                lv_label_set_text(duration_labels[i], percent_text);
                printf("UI: Updated duration_labels[%d] to: %s\n", i, percent_text);
            } else {
                printf("WARNING: duration_labels[%d] is NULL\n", i);
            }
        }

        // 更新圆弧
        int start_angle = 0;
        for(int i = 0; i < 4; i++) {
            if(duration_arcs[i]) {
                int angle = (duration_values[i] * 360) / duration_total;
                lv_arc_set_rotation(duration_arcs[i], start_angle);
                lv_arc_set_bg_angles(duration_arcs[i], 0, angle);
                start_angle += angle;
            }
        }
        printf("UI: Updated parking duration arcs\n");
    }

    // 更新车辆类型分布圆弧图和标签
    int vehicle_total = data->vehicle_type_truck + data->vehicle_type_suv + data->vehicle_type_car;

    if(vehicle_total > 0) {
        int vehicle_values[] = {data->vehicle_type_truck, data->vehicle_type_suv, data->vehicle_type_car};

        for(int i = 0; i < 3; i++) {
            if(vehicle_labels[i]) {
                char percent_text[20];
                int percentage = (vehicle_values[i] * 100) / vehicle_total;
                snprintf(percent_text, sizeof(percent_text), "%d%%", percentage);
                lv_label_set_text(vehicle_labels[i], percent_text);
                printf("UI: Updated vehicle_labels[%d] to: %s\n", i, percent_text);
            } else {
                printf("WARNING: vehicle_labels[%d] is NULL\n", i);
            }
        }

        int start_angle = 0;
        for(int i = 0; i < 3; i++) {
            if(vehicle_arcs[i]) {
                int angle = (vehicle_values[i] * 360) / vehicle_total;
                lv_arc_set_rotation(vehicle_arcs[i], start_angle);
                lv_arc_set_bg_angles(vehicle_arcs[i], 0, angle);
                start_angle += angle;
            }
        }
        printf("UI: Updated vehicle type arcs\n");
    }

    // 更新高峰时段横向柱状图
    int hour_values_data[] = {data->hour_6_count,  data->hour_8_count,  data->hour_10_count, data->hour_12_count,
                              data->hour_14_count, data->hour_16_count, data->hour_18_count, data->hour_20_count};

    // 使用相同的布局参数
    int chart_x        = 40;
    int chart_width    = 160;
    int max_value      = 140;
    float scale_factor = (float)(chart_width - 20) / max_value;

    for(int i = 0; i < 8; i++) {
        int bar_width = (int)(hour_values_data[i] * scale_factor);

        // 更新柱状图宽度
        if(hour_bars[i]) {
            lv_obj_set_width(hour_bars[i], bar_width);

            // 更新颜色
            if(hour_values_data[i] > 100) {
                lv_obj_set_style_bg_color(hour_bars[i], COLOR_DANGER, 0);
            } else if(hour_values_data[i] > 70) {
                lv_obj_set_style_bg_color(hour_bars[i], COLOR_WARNING, 0);
            } else {
                lv_obj_set_style_bg_color(hour_bars[i], COLOR_SUCCESS, 0);
            }
        }
    }

    // 更新设施评分
    if(facility_score_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%.1f/5", data->facility_score_x100 / 100.0);
        lv_label_set_text(facility_score_label, buffer);
        printf("UI: Updated facility_score to: %s\n", buffer);
    }

    // 更新服务评分
    if(service_score_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%.1f/5", data->service_score_x100 / 100.0);
        lv_label_set_text(service_score_label, buffer);
        printf("UI: Updated service_score to: %s\n", buffer);
    }

    // 更新总体满意度
    if(satisfaction_score_label) {
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "%d", data->satisfaction_score);
        lv_label_set_text(satisfaction_score_label, buffer);
        printf("UI: Updated satisfaction_score to: %s\n", buffer);
    }

    printf("UI: Updated peak hours bar charts\n");

    printf("=== UI UPDATE COMPLETE ===\n");
}

// 初始化样式
// 修改 init_styles 函数
void init_styles(void)
{
    // printf("DEBUG: Initializing styles...\n");

    // 卡片样式
    // printf("DEBUG: Creating card style\n");
    lv_style_init(&style_card);
    lv_style_set_radius(&style_card, 10);
    lv_style_set_bg_opa(&style_card, LV_OPA_COVER);
    lv_style_set_bg_color(&style_card, COLOR_CARD_BG);
    lv_style_set_shadow_width(&style_card, 10);
    lv_style_set_shadow_color(&style_card, lv_color_hex(0xCCCCCC));
    lv_style_set_shadow_ofs_y(&style_card, 5);
    lv_style_set_pad_all(&style_card, 10);
    // printf("DEBUG: Card style created\n");

    // 标题样式
    // printf("DEBUG: Creating title style\n");
    lv_style_init(&style_title);
    lv_style_set_text_font(&style_title, &chinese_ziku);
    lv_style_set_text_color(&style_title, lv_color_black());
    // printf("DEBUG: Title style created\n");

    // 数值样式
    // printf("DEBUG: Creating value style\n");
    lv_style_init(&style_value);
    lv_style_set_text_font(&style_value, &chinese_ziku);
    lv_style_set_text_color(&style_value, COLOR_PRIMARY);
    // printf("DEBUG: Value style created\n");

    // 标签样式
    // printf("DEBUG: Creating label style\n");
    lv_style_init(&style_label);
    lv_style_set_text_font(&style_label, &chinese_ziku);
    lv_style_set_text_color(&style_label, lv_color_hex(0x666666));
    // printf("DEBUG: Label style created\n");

    // printf("DEBUG: All styles initialized successfully\n");
}

// 修改create_direct_stat_item函数，保存关键标签的指针
// 在 create_direct_stat_item 函数中添加评分标签的保存
void create_direct_stat_item(lv_obj_t * parent, const char * label, const char * value, int label_x, int y, int value_x)
{
    // 创建标签
    lv_obj_t * label_obj = lv_label_create(parent);
    lv_label_set_text(label_obj, label);
    lv_obj_add_style(label_obj, &style_label, 0);
    lv_obj_set_pos(label_obj, label_x, y);

    // 创建数值 - 使用单独的value_x参数
    lv_obj_t * value_obj = lv_label_create(parent);
    lv_label_set_text(value_obj, value);
    lv_obj_add_style(value_obj, &style_value, 0);
    lv_obj_set_pos(value_obj, value_x, y);

    // 保存关键标签的指针用于实时更新
    if(strcmp(label, "总车位数") == 0) {
        total_spaces_label = value_obj;
    } else if(strcmp(label, "当前空余车位") == 0) {
        available_spaces_label = value_obj;
    } else if(strcmp(label, "今日车辆进场") == 0) {
        vehicles_in_label = value_obj;
    } else if(strcmp(label, "今日车辆出场") == 0) {
        vehicles_out_label = value_obj;
    } else if(strcmp(label, "温度") == 0) {
        temperature_label = value_obj;
    } else if(strcmp(label, "湿度") == 0) {
        humidity_label = value_obj;
    } else if(strcmp(label, "今日识别车辆") == 0) {
        recognized_vehicles_label = value_obj;
    } else if(strcmp(label, "未识别率") == 0) {
        unrecognized_rate_label = value_obj;
    } else if(strcmp(label, "设施评分") == 0) {
        facility_score_label = value_obj;
    } else if(strcmp(label, "服务评分") == 0) {
        service_score_label = value_obj;
    } else if(strcmp(label, "总体满意度") == 0) {
        // 这个已经在其他地方保存了
    }
}

// 直接创建楼层进度条（不使用中间容器）
// 修改 create_direct_floor_progress 函数，保存楼层标签指针
void create_direct_floor_progress(lv_obj_t * parent, const char * label_prefix, int total_spaces, int percent, int y,
                                  int floor_index)
{
    int x = 5;

    // 创建完整的标签文本
    char label_text[64];
    snprintf(label_text, sizeof(label_text), "%s %d个", label_prefix, total_spaces);

    // 创建标签
    lv_obj_t * label_obj = lv_label_create(parent);
    lv_label_set_text(label_obj, label_text);
    lv_obj_add_style(label_obj, &style_label, 0);
    lv_obj_set_pos(label_obj, x, y);

    // 保存楼层标签指针用于更新
    switch(floor_index) {
        case 0:
            floor_b1_label = label_obj;
            printf("DEBUG: Saved floor_b1_label = %p\n", (void *)floor_b1_label);
            break;
        case 1:
            floor_b2_label = label_obj;
            printf("DEBUG: Saved floor_b2_label = %p\n", (void *)floor_b2_label);
            break;
        case 2:
            floor_b3_label = label_obj;
            printf("DEBUG: Saved floor_b3_label = %p\n", (void *)floor_b3_label);
            break;
    }

    // 创建百分比标签
    lv_obj_t * percent_label = lv_label_create(parent);
    char percent_str[10];
    snprintf(percent_str, sizeof(percent_str), "%d%%", percent);
    lv_label_set_text(percent_label, percent_str);
    lv_obj_add_style(percent_label, &style_value, 0);
    lv_obj_set_pos(percent_label, x + 170, y);

    // 保存百分比标签指针
    switch(floor_index) {
        case 0: floor_b1_percent_label = percent_label; break;
        case 1: floor_b2_percent_label = percent_label; break;
        case 2: floor_b3_percent_label = percent_label; break;
    }

    // 创建进度条
    lv_obj_t * bar = lv_bar_create(parent);
    lv_obj_set_size(bar, 220, 8);
    lv_obj_set_pos(bar, x, y + 25);
    lv_bar_set_value(bar, percent, LV_ANIM_ON);

    // 设置进度条颜色
    lv_obj_set_style_bg_color(bar, lv_color_hex(0xE0E0E0), LV_PART_MAIN);
    lv_obj_set_style_bg_color(bar, COLOR_PRIMARY, LV_PART_INDICATOR);

    // 保存进度条指针
    switch(floor_index) {
        case 0: floor_b1_bar = bar; break;
        case 1: floor_b2_bar = bar; break;
        case 2: floor_b3_bar = bar; break;
    }
}

// 创建总览面板函数
void create_overview_panel(lv_obj_t * parent)
{
    // 创建总览容器 - 作为面板的主容器
    lv_obj_t * cont = lv_obj_create(parent);
    // 设置容器尺寸：宽度250像素，高度460像素
    lv_obj_set_size(cont, 250, 460);
    // 设置容器位置：距离父容器左侧10像素，顶部10像素
    lv_obj_set_pos(cont, 10, 10);
    // 为容器添加卡片样式，使其具有圆角、背景色和阴影效果
    lv_obj_add_style(cont, &style_card, 0);

    // 创建标题标签
    lv_obj_t * title = lv_label_create(cont);
    // 设置标题文本内容为"停车场总览"
    lv_label_set_text(title, "停车场总览");
    // 为标题添加标题样式（通常包括字体、颜色等）
    lv_obj_add_style(title, &style_title, 0);
    // 设置标题位置：水平居中（70像素），垂直距离顶部15像素
    lv_obj_set_pos(title, 70, 15);

    parking_data_t initial_data;

    // 使用实时数据创建统计项
    // 定义字符串缓冲区用于格式化显示数据
    char total_str[32], available_str[32], in_str[32], out_str[32];
    char temp_str[32], humidity_str[32];

    // 将数值数据格式化为字符串
    // 格式化总车位数
    snprintf(total_str, sizeof(total_str), "%d", initial_data.total_spaces);
    // 格式化当前空余车位数
    snprintf(available_str, sizeof(available_str), "%d", initial_data.available_spaces);
    // 格式化今日车辆进场数
    snprintf(in_str, sizeof(in_str), "%d", initial_data.vehicles_in);
    // 格式化今日车辆出场数
    snprintf(out_str, sizeof(out_str), "%d", initial_data.vehicles_out);
    // 格式化温度值
    snprintf(temp_str, sizeof(temp_str), "%d", initial_data.temperature);
    // 格式化湿度值（添加百分比符号）
    snprintf(humidity_str, sizeof(humidity_str), "%d%%", initial_data.humidity);

    // 创建直接统计项（标签+数值对）
    // 创建"总车位数"统计项：标签位置(20,50)，数值位置(170,50)
    create_direct_stat_item(cont, "总车位数", total_str, 20, 50, 170);
    // 创建"当前空余车位"统计项：标签位置(20,90)，数值位置(170,90)
    create_direct_stat_item(cont, "当前空余车位", available_str, 20, 90, 170);
    // 创建"今日车辆进场"统计项：标签位置(20,130)，数值位置(170,130)
    create_direct_stat_item(cont, "今日车辆进场", in_str, 20, 130, 170);
    // 创建"今日车辆出场"统计项：标签位置(20,170)，数值位置(170,170)
    create_direct_stat_item(cont, "今日车辆出场", out_str, 20, 170, 170);
    // 创建"高峰时段"统计项：标签位置(20,210)，数值位置(108,210)
    create_direct_stat_item(cont, "高峰时段", "08:00-10:00", 20, 210, 108);

    // 创建楼层进度条 - 使用动态数据
    // 创建地下1层进度条：位置y=250，楼层索引0
    create_direct_floor_progress(cont, "地下1层", initial_data.floor_b1_total, initial_data.floor_b1_utilization, 250,
                                 0);
    // 创建地下2层进度条：位置y=300，楼层索引1
    create_direct_floor_progress(cont, "地下2层", initial_data.floor_b2_total, initial_data.floor_b2_utilization, 300,
                                 1);
    // 创建地下3层进度条：位置y=350，楼层索引2
    create_direct_floor_progress(cont, "地下3层", initial_data.floor_b3_total, initial_data.floor_b3_utilization, 350,
                                 2);

    // 添加环境数据显示
    // 创建温度显示：标签位置(10,390)，数值位置(70,390)
    create_direct_stat_item(cont, "温度", temp_str, 10, 390, 70);
    // 创建湿度显示：标签位置(120,390)，数值位置(175,390)
    create_direct_stat_item(cont, "湿度", humidity_str, 120, 390, 175);
}

// 创建对齐的多段环形图函数
// 参数说明：
// parent - 父容器对象
// values - 数值数组，表示各部分的比例
// labels - 标签数组，对应各部分的名称
// colors - 颜色数组，定义各部分的显示颜色
// count - 数据项数量
// title - 图表标题（当前函数中未使用）
// x, y - 图表在父容器中的位置坐标
// size - 环形图的直径大小
// chart_type - 图表类型标识，用于区分不同类型的图表
lv_obj_t * create_multi_arc_chart_aligned(lv_obj_t * parent, int * values, const char ** labels, lv_color_t * colors,
                                          int count, const char * title, int x, int y, int size, int chart_type)
{
    // 创建图表的主容器
    lv_obj_t * cont = lv_obj_create(parent);
    // 移除容器的所有默认样式
    lv_obj_remove_style_all(cont);
    // 设置容器尺寸：宽度=环形图直径+150（为图例留空间），高度=环形图直径+40
    lv_obj_set_size(cont, size + 150, size + 40);
    // 设置容器在父容器中的位置
    lv_obj_set_pos(cont, x, y);

    // 计算所有数值的总和，用于计算百分比
    int total = 0;
    for(int i = 0; i < count; i++) {
        total += values[i];
    }

    // 创建图例容器（位于图表左侧）
    lv_obj_t * legend_cont = lv_obj_create(cont);
    // 移除图例容器的所有默认样式
    lv_obj_remove_style_all(legend_cont);
    // 设置图例容器尺寸：宽度130像素，高度根据数据项数量计算（每个项28像素）
    lv_obj_set_size(legend_cont, 130, count * 28);
    // 对齐图例容器：在父容器中左对齐、垂直居中，y轴偏移10像素
    lv_obj_align(legend_cont, LV_ALIGN_LEFT_MID, 0, 10);

    // 循环创建每个数据项的图例
    for(int i = 0; i < count; i++) {
        // 创建单个图例项容器
        lv_obj_t * legend_item = lv_obj_create(legend_cont);
        // 移除图例项的所有默认样式
        lv_obj_remove_style_all(legend_item);
        // 设置图例项尺寸：宽度130像素，高度23像素
        lv_obj_set_size(legend_item, 130, 23);
        // 设置图例项位置：x=0，y=索引*25（垂直排列，间距25像素）
        lv_obj_set_pos(legend_item, 0, i * 25);

        // 创建颜色标记（小方块）
        lv_obj_t * color_indicator = lv_obj_create(legend_item);
        // 设置颜色标记尺寸：10x10像素的正方形
        lv_obj_set_size(color_indicator, 10, 10);
        // 设置颜色标记的背景色，使用传入的颜色数组对应颜色
        lv_obj_set_style_bg_color(color_indicator, colors[i], 0);
        // 设置颜色标记的圆角半径：2像素（轻微圆角）
        lv_obj_set_style_radius(color_indicator, 2, 0);
        // 对齐颜色标记：在图例项中左对齐、垂直居中，y轴偏移5像素
        lv_obj_align(color_indicator, LV_ALIGN_LEFT_MID, 0, 5);

        // 创建百分比标签
        lv_obj_t * legend_label = lv_label_create(legend_item);
        // 定义百分比文本缓冲区
        char legend_text[20];
        // 计算当前数据项的百分比：如果总数大于0则计算，否则为0
        int percentage = (total > 0) ? (values[i] * 100) / total : 0;
        // 格式化百分比文本（如"25%"）
        snprintf(legend_text, sizeof(legend_text), "%d%%", percentage);
        // 设置标签文本内容
        lv_label_set_text(legend_label, legend_text);
        // 设置标签字体为中文字体
        lv_obj_set_style_text_font(legend_label, &chinese_ziku, 0);
        // 设置标签文字颜色，使用与对应数据段相同的颜色
        lv_obj_set_style_text_color(legend_label, colors[i], 0);
        // 对齐百分比标签：在图例项中右对齐、垂直居中，y轴偏移4像素
        lv_obj_align(legend_label, LV_ALIGN_RIGHT_MID, 0, 4);

        // 保存标签指针用于更新 - 根据图表类型保存到不同的全局数组
        if(chart_type == 0) {                      // 停车时长分布图表
            if(i < 4) {                            // 确保索引在数组范围内
                duration_labels[i] = legend_label; // 保存到停车时长标签数组
                // 输出调试信息，显示保存的指针地址
                printf("DEBUG: Saved duration_labels[%d] = %p\n", i, (void *)legend_label);
            }
        } else if(chart_type == 1) {              // 车辆类型分布图表
            if(i < 3) {                           // 确保索引在数组范围内
                vehicle_labels[i] = legend_label; // 保存到车辆类型标签数组
                // 输出调试信息，显示保存的指针地址
                printf("DEBUG: Saved vehicle_labels[%d] = %p\n", i, (void *)legend_label);
            }
        }

        // 创建数据项名称标签
        lv_obj_t * name_label = lv_label_create(legend_item);
        // 设置名称标签文本，使用传入的标签数组
        lv_label_set_text(name_label, labels[i]);
        // 设置名称标签字体为中文字体
        lv_obj_set_style_text_font(name_label, &chinese_ziku, 0);
        // 设置名称标签文字颜色为灰色（十六进制颜色值0x666666）
        lv_obj_set_style_text_color(name_label, lv_color_hex(0x666666), 0);
        // 对齐名称标签：相对于颜色标记右侧对齐，水平偏移3像素，垂直偏移-3像素
        lv_obj_align_to(name_label, color_indicator, LV_ALIGN_OUT_RIGHT_MID, 3, -3);
    }

    // 创建环形图（位于图表右侧）
    int start_angle = 0; // 起始角度，从0度开始
    for(int i = 0; i < count; i++) {
        // 计算当前数据段的角度（基于百分比）
        int angle = (values[i] * 360) / total;

        // 创建圆弧对象
        lv_obj_t * arc = lv_arc_create(cont);
        // 设置圆弧尺寸（直径）
        lv_obj_set_size(arc, size, size);
        // 对齐圆弧：在容器中右对齐、垂直居中
        lv_obj_align(arc, LV_ALIGN_RIGHT_MID, 0, 0);
        // 设置圆弧的旋转角度（确定起始位置）
        lv_arc_set_rotation(arc, start_angle);
        // 设置圆弧的背景角度范围（从0到计算的角度）
        lv_arc_set_bg_angles(arc, 0, angle);
        // 设置圆弧的值（固定为100，因为角度已经通过bg_angles设置）
        lv_arc_set_value(arc, 100);

        // 设置圆弧样式
        // 设置圆弧宽度（主线部分）：12像素
        lv_obj_set_style_arc_width(arc, 12, LV_PART_MAIN);
        // 设置圆弧颜色（主线部分）：使用对应的颜色
        lv_obj_set_style_arc_color(arc, colors[i], LV_PART_MAIN);
        // 设置圆弧宽度（指示器部分）：12像素
        lv_obj_set_style_arc_width(arc, 12, LV_PART_INDICATOR);
        // 设置圆弧颜色（指示器部分）：使用对应的颜色
        lv_obj_set_style_arc_color(arc, colors[i], LV_PART_INDICATOR);
        // 移除旋钮样式（不需要旋钮功能）
        lv_obj_remove_style(arc, NULL, LV_PART_KNOB);

        // 保存圆弧指针用于后续更新
        if(chart_type == 0) {                 // 停车时长分布图表
            if(i < 4) duration_arcs[i] = arc; // 保存到停车时长圆弧数组
        } else if(chart_type == 1) {          // 车辆类型分布图表
            if(i < 3) vehicle_arcs[i] = arc;  // 保存到车辆类型圆弧数组
        }

        // 更新起始角度，为下一个圆弧段做准备
        start_angle += angle;
    }

    // 返回创建完成的图表容器
    return cont;
}

// 创建客户行为分析面板函数
void create_customer_behavior_panel(lv_obj_t * parent)
{
    // 创建客户行为分析面板的主容器
    lv_obj_t * cont = lv_obj_create(parent);
    // 设置容器尺寸：宽度250像素，高度220像素
    lv_obj_set_size(cont, 250, 220);
    // 设置容器位置：距离父容器左侧270像素，顶部10像素
    // (位于总览面板右侧，与总览面板顶部对齐)
    lv_obj_set_pos(cont, 270, 10);
    // 为容器添加卡片样式，使其具有统一样式效果
    lv_obj_add_style(cont, &style_card, 0);

    // 创建面板标题
    lv_obj_t * title = lv_label_create(cont);
    // 设置标题文本内容为"客户行为分析"
    lv_label_set_text(title, "客户行为分析");
    // 为标题添加标题样式（包括字体、颜色等属性）
    lv_obj_add_style(title, &style_title, 0);
    // 设置标题位置：水平居中（55像素），垂直位置在顶部（0像素）
    lv_obj_set_pos(title, 55, 0);

    // 创建统计数据项
    // 创建"平均停车时长"统计项：标签位置(0,25)，数值位置(140,25)
    // 显示固定值"2.5小时"（实际项目中应该使用动态数据）
    create_direct_stat_item(cont, "平均停车时长", "2.5小时", 0, 25, 140);
    // 创建"平均消费金额"统计项：标签位置(0,50)，数值位置(140,50)
    // 显示固定值"$45.60"
    create_direct_stat_item(cont, "平均消费金额", "$45.60", 0, 50, 140);
    // 创建"会员占比"统计项：标签位置(0,75)，数值位置(100,75)
    // 显示固定值"68%"
    create_direct_stat_item(cont, "会员占比", "68%", 0, 75, 100);

    // 创建环形图显示停车时长分布
    // 定义停车时长分布的数值数组（百分比）
    // 数组顺序：>=4小时, <=1小时, 2-4小时, 1-2小时
    // 注意：这里的数值是硬编码的，实际应该使用动态数据
    int duration_values[] = {25, 35, 20, 20}; // >=4h, <=1h, 2-4h, 1-2h
    // 定义对应的标签文本数组
    const char * duration_labels[] = {">=4h", "<=1h", "2-4h", "1-2h"};
    // 定义环形图各部分的颜色数组
    // 使用预定义的颜色主题：主色、成功色、警告色、辅助色
    lv_color_t duration_colors[] = {COLOR_PRIMARY, COLOR_SUCCESS, COLOR_WARNING, COLOR_SECONDARY};

    // 创建多段环形图
    // 参数说明：
    // cont - 父容器
    // duration_values - 数值数组
    // duration_labels - 标签数组
    // duration_colors - 颜色数组
    // 4 - 数据项数量
    // "停车时长分布" - 图表标题
    // 0, 90 - 图表在容器中的位置(x,y)
    // 65 - 环形图直径
    // 0 - 图表类型标识（0表示停车时长分布图表）
    create_multi_arc_chart_aligned(cont, duration_values, duration_labels, duration_colors, 4, "停车时长分布", 0, 90,
                                   65, 0);
}

// 创建紧凑版高峰时段与流量预测面板函数
void create_peak_hours_panel_compact(lv_obj_t * parent)
{
    // 创建高峰时段面板的主容器
    lv_obj_t * cont = lv_obj_create(parent);
    // 设置容器尺寸：宽度250像素，高度220像素
    lv_obj_set_size(cont, 250, 220);
    // 设置容器位置：距离父容器左侧530像素，顶部10像素
    // (位于客户行为分析面板右侧，与前面两个面板顶部对齐)
    lv_obj_set_pos(cont, 530, 10);
    // 为容器添加卡片样式，保持整体设计一致性
    lv_obj_add_style(cont, &style_card, 0);

    // 创建面板标题
    lv_obj_t * title = lv_label_create(cont);
    // 设置标题文本内容为"高峰时段与流量预测"
    lv_label_set_text(title, "高峰时段与流量预测");
    // 为标题添加标题样式
    lv_obj_add_style(title, &style_title, 0);
    // 设置标题位置：水平位置25像素，顶部对齐
    lv_obj_set_pos(title, 25, 0);

    // 获取初始数据用于显示
    // 声明停车场数据结构体变量
    parking_data_t initial_data;
    // 从数据模块获取当前停车场数据
    get_parking_data(&initial_data);

    // 定义柱状图数据数组 - 使用8个时段的车辆计数数据
    int bar_values[] = {initial_data.hour_6_count,  initial_data.hour_8_count,  initial_data.hour_10_count,
                        initial_data.hour_12_count, initial_data.hour_14_count, initial_data.hour_16_count,
                        initial_data.hour_18_count, initial_data.hour_20_count};

    // 定义时间标签数组 - 对应8个时段
    const char * times[] = {"6:00", "8:00", "10:00", "12:00", "14:00", "16:00", "18:00", "20:00"};

    // 紧凑布局参数设置
    int chart_x     = 40;  // 图表区域起始X坐标
    int chart_y     = 30;  // 图表区域起始Y坐标
    int chart_width = 160; // 图表总宽度
    int bar_height  = 15;  // 每个柱状条的高度
    int bar_spacing = 2;   // 柱状条之间的间距
    int max_value   = 140; // 假设的最大值，用于计算缩放比例
    // 计算缩放因子：将数值映射到柱状图宽度的比例
    // (chart_width - 20) 为实际可用宽度，留出20像素边距
    float scale_factor = (float)(chart_width - 20) / max_value;

    // 创建时间标签（Y轴标签 - 左侧）
    for(int i = 0; i < 8; i++) {
        // 创建单个时间标签
        lv_obj_t * time_label = lv_label_create(cont);
        // 设置时间标签文本（如"6:00"）
        lv_label_set_text(time_label, times[i]);
        // 为时间标签添加标签样式
        lv_obj_add_style(time_label, &style_label, 0);
        // 设置时间标签位置：
        // x = chart_x - 40（在图表左侧）
        // y = 根据索引计算垂直位置，-5像素微调垂直居中
        lv_obj_set_pos(time_label, chart_x - 40, chart_y + i * (bar_height + bar_spacing) - 5);
    }

    // 创建横向柱状条 - 只保存柱状图指针用于后续更新
    for(int i = 0; i < 8; i++) {
        // 计算当前柱状条的宽度：数值 × 缩放因子
        int bar_width = (int)(bar_values[i] * scale_factor);
        // 计算当前柱状条的Y坐标位置
        int y_pos = chart_y + i * (bar_height + bar_spacing);

        // 创建柱状条背景（灰色底条）
        lv_obj_t * bar_bg = lv_obj_create(cont);
        // 设置背景条尺寸：完整图表宽度，固定高度
        lv_obj_set_size(bar_bg, chart_width, bar_height);
        // 设置背景条位置：x偏移20像素（为Y轴标签留空间）
        lv_obj_set_pos(bar_bg, chart_x + 20, y_pos);
        // 设置背景条颜色：浅灰色（十六进制0xF0F0F0）
        lv_obj_set_style_bg_color(bar_bg, lv_color_hex(0xF0F0F0), 0);
        // 设置背景条圆角：2像素
        lv_obj_set_style_radius(bar_bg, 2, 0);

        // 创建柱状条前景（彩色条）- 保存这个指针用于更新
        lv_obj_t * bar = lv_obj_create(cont);
        // 设置彩色条尺寸：根据计算出的宽度，固定高度
        lv_obj_set_size(bar, bar_width, bar_height);
        // 设置彩色条位置：与背景条相同位置
        lv_obj_set_pos(bar, chart_x + 20, y_pos);

        // 根据数值大小设置不同的颜色（语义化颜色编码）
        if(bar_values[i] > 100) {
            // 数值>100：使用危险色（红色），表示高峰拥堵
            lv_obj_set_style_bg_color(bar, COLOR_DANGER, 0);
        } else if(bar_values[i] > 70) {
            // 数值70-100：使用警告色（橙色），表示中等流量
            lv_obj_set_style_bg_color(bar, COLOR_WARNING, 0);
        } else {
            // 数值<=70：使用成功色（绿色），表示畅通
            lv_obj_set_style_bg_color(bar, COLOR_SUCCESS, 0);
        }

        // 设置彩色条圆角：2像素，与背景条保持一致
        lv_obj_set_style_radius(bar, 2, 0);

        // 保存柱状图指针到全局数组（不创建数值标签以保持简洁）
        hour_bars[i] = bar;
    }

    // 添加网格线和X轴标签（数值刻度）
    for(int i = 0; i <= 4; i++) {
        // 计算网格线和标签的X位置：等分图表宽度
        int x_pos = chart_x + 20 + i * 35;
        // 计算对应的数值：0, 35, 70, 105, 140
        int value = i * 35;

        // 创建网格线
        lv_obj_t * grid_line = lv_obj_create(cont);
        // 设置网格线尺寸：1像素宽，覆盖所有柱状条的高度
        lv_obj_set_size(grid_line, 1, 8 * (bar_height + bar_spacing));
        // 设置网格线位置
        lv_obj_set_pos(grid_line, x_pos, chart_y);
        // 设置网格线颜色：浅灰色（十六进制0xE0E0E0）
        lv_obj_set_style_bg_color(grid_line, lv_color_hex(0xE0E0E0), 0);

        // 创建X轴数值标签
        lv_obj_t * value_label = lv_label_create(cont);
        // 定义标签文本缓冲区
        char label[8];
        // 格式化数值文本
        snprintf(label, sizeof(label), "%d", value);
        // 设置标签文本
        lv_label_set_text(value_label, label);
        // 为数值标签添加标签样式
        lv_obj_add_style(value_label, &style_label, 0);
        // 设置数值标签位置：
        // x = 网格线位置-10像素（居中调整）
        // y = 图表底部下方
        lv_obj_set_pos(value_label, x_pos - 10, chart_y + 8 * (bar_height + bar_spacing) + 3);
    }
}

// 创建车牌识别与车辆信息面板函数
void create_license_plate_panel(lv_obj_t * parent)
{
    // 创建车牌识别面板的主容器
    lv_obj_t * cont = lv_obj_create(parent);
    // 设置容器尺寸：宽度250像素，高度220像素
    lv_obj_set_size(cont, 250, 220);
    // 设置容器位置：距离父容器左侧270像素，顶部240像素
    // (位于客户行为分析面板下方，形成2x2网格布局)
    lv_obj_set_pos(cont, 270, 240);
    // 为容器添加卡片样式，保持整体设计一致性
    lv_obj_add_style(cont, &style_card, 0);

    // 创建面板标题
    lv_obj_t * title = lv_label_create(cont);
    // 设置标题文本内容为"车牌识别与车辆信息"
    lv_label_set_text(title, "车牌识别与车辆信息");
    // 为标题添加标题样式
    lv_obj_add_style(title, &style_title, 0);
    // 设置标题位置：水平位置25像素，顶部对齐
    lv_obj_set_pos(title, 25, 0);

    // 获取初始数据用于显示
    // 声明停车场数据结构体变量
    parking_data_t initial_data;
    // 从数据模块获取当前停车场数据
    get_parking_data(&initial_data);

    // 统计数据 - 左侧显示识别统计数据
    // 定义字符串缓冲区用于格式化显示数据
    char recognized_str[32], unrecognized_str[32];
    // 格式化今日识别车辆数：将整数值转换为字符串
    snprintf(recognized_str, sizeof(recognized_str), "%d", initial_data.recognized_vehicles);
    // 格式化未识别率：将x100的整数值转换为浮点百分比字符串
    // 例如：230 -> 2.30%
    snprintf(unrecognized_str, sizeof(unrecognized_str), "%.1f%%", initial_data.unrecognized_rate_x100 / 100.0);

    // 使用修改后的 create_direct_stat_item 保存指针
    // 创建"今日识别车辆"统计项：标签位置(0,25)，数值位置(140,25)
    // 这个函数会保存指针到全局变量，支持后续动态更新
    create_direct_stat_item(cont, "今日识别车辆", recognized_str, 0, 25, 140);
    // 创建"未识别率"统计项：标签位置(0,50)，数值位置(140,50)
    // 同样会保存指针到全局变量
    create_direct_stat_item(cont, "未识别率", unrecognized_str, 0, 50, 140);

    // 创建环形图显示车辆类型分布 - 右侧显示
    // 定义车辆类型数据数组：货车、SUV、轿车的数量
    int vehicle_values[] = {initial_data.vehicle_type_truck, initial_data.vehicle_type_suv,
                            initial_data.vehicle_type_car};
    // 定义车辆类型标签数组
    const char * vehicle_labels[] = {"货车", "SUV", "轿车"};
    // 定义车辆类型颜色数组：使用预定义的颜色主题
    lv_color_t vehicle_colors[] = {COLOR_PRIMARY, COLOR_SUCCESS, COLOR_WARNING};

    // 创建多段环形图展示车辆类型分布
    // 参数说明：
    // cont - 父容器
    // vehicle_values - 车辆类型数值数组
    // vehicle_labels - 车辆类型标签数组
    // vehicle_colors - 车辆类型颜色数组
    // 3 - 数据项数量（货车、SUV、轿车）
    // NULL - 图表标题（设为NULL不显示标题）
    // 0, 60 - 图表在容器中的位置(x,y)
    // 65 - 环形图直径
    // 1 - 图表类型标识（1表示车辆类型分布图表）
    create_multi_arc_chart_aligned(cont, vehicle_values, vehicle_labels, vehicle_colors, 3, NULL, 0, 60, 65, 1);

    // 添加今日热门车牌前缀信息
    lv_obj_t * popular_label = lv_label_create(cont);
    // 设置热门车牌文本内容（硬编码示例数据）
    lv_label_set_text(popular_label, "热门车牌: 粤B, 京A, 沪C");
    // 为热门车牌标签添加标签样式
    lv_obj_add_style(popular_label, &style_label, 0);
    // 设置热门车牌标签位置：左侧对齐，垂直位置160像素（靠近底部）
    lv_obj_set_pos(popular_label, 0, 160);
}

// 创建客户反馈与满意度面板函数
void create_feedback_panel(lv_obj_t * parent)
{
    // 创建反馈面板的主容器
    lv_obj_t * cont = lv_obj_create(parent);
    // 设置容器尺寸：宽度250像素，高度220像素
    lv_obj_set_size(cont, 250, 220);
    // 设置容器位置：距离父容器左侧530像素，顶部240像素
    // (位于高峰时段面板下方，形成完整的2x2网格布局)
    lv_obj_set_pos(cont, 530, 240);
    // 为容器添加卡片样式，保持整体设计一致性
    lv_obj_add_style(cont, &style_card, 0);

    // 创建面板标题
    lv_obj_t * title = lv_label_create(cont);
    // 设置标题文本内容为"客户反应与满意度"
    lv_label_set_text(title, "客户反应与满意度");
    // 为标题添加标题样式
    lv_obj_add_style(title, &style_title, 0);
    // 设置标题位置：水平位置35像素，顶部对齐
    lv_obj_set_pos(title, 35, 0);

    // 获取初始数据用于显示
    // 声明停车场数据结构体变量
    parking_data_t initial_data;
    // 从数据模块获取当前停车场数据
    get_parking_data(&initial_data);

    // 反馈信息 - 只显示常见反应和评分，移除总体满意度（单独显示）
    // 定义字符串缓冲区用于格式化显示数据
    char common_feedback_str[64], facility_score_str[32], service_score_str[32];

    // 显示常见反应
    // 格式化常见反馈文本：直接复制字符串内容
    snprintf(common_feedback_str, sizeof(common_feedback_str), "%s", initial_data.common_feedback);
    // 创建"最常见反应"统计项：标签位置(0,45)，数值位置(140,45)
    // 显示用户最常见的反馈意见（如"车位不足"）
    create_direct_stat_item(cont, "最常见反应", common_feedback_str, 0, 45, 140);

    // 显示设施评分和服务评分
    // 格式化设施评分：将x100的整数值转换为浮点数并格式化为"x.x/5"
    // 例如：450 -> 4.50/5 -> 显示为4.5/5
    snprintf(facility_score_str, sizeof(facility_score_str), "%.1f/5", initial_data.facility_score_x100 / 100.0);
    // 格式化服务评分：同样转换为"x.x/5"格式
    snprintf(service_score_str, sizeof(service_score_str), "%.1f/5", initial_data.service_score_x100 / 100.0);

    // 创建"设施评分"统计项：标签位置(0,70)，数值位置(140,70)
    create_direct_stat_item(cont, "设施评分", facility_score_str, 0, 70, 140);
    // 创建"服务评分"统计项：标签位置(0,95)，数值位置(140,95)
    create_direct_stat_item(cont, "服务评分", service_score_str, 0, 95, 140);

    // 只在底部中央显示总体满意度（大字突出显示）
    // 创建总体满意度数值显示标签
    lv_obj_t * satisfaction_display = lv_label_create(cont);
    // 定义满意度数值字符串缓冲区
    char satisfaction_display_str[32];
    // 格式化总体满意度数值：直接显示整数（如90）
    snprintf(satisfaction_display_str, sizeof(satisfaction_display_str), "%d", initial_data.satisfaction_score);
    // 设置满意度数值文本
    lv_label_set_text(satisfaction_display, satisfaction_display_str);
    // 设置满意度数值字体为中文字体（第一次设置）
    lv_obj_set_style_text_font(satisfaction_display, &chinese_ziku, 0);
    // 设置满意度数值颜色为成功色（绿色），突出正面评价
    lv_obj_set_style_text_color(satisfaction_display, COLOR_SUCCESS, 0);
    // 再次设置满意度数值字体为中文字体（重复设置，可能是为了确保生效）
    lv_obj_set_style_text_font(satisfaction_display, &chinese_ziku, 0);
    // 对齐满意度数值：在容器底部中央，垂直偏移-40像素（从底部向上40像素）
    lv_obj_align(satisfaction_display, LV_ALIGN_BOTTOM_MID, 0, -40);

    // 保存满意度显示标签指针到全局变量，用于后续动态更新
    satisfaction_score_label = satisfaction_display;

    // 添加满意度标题标签（在数值下方）
    lv_obj_t * satisfaction_label = lv_label_create(cont);
    // 设置满意度标题文本
    lv_label_set_text(satisfaction_label, "总体满意度");
    // 为满意度标题添加标签样式（通常比数值字体小，颜色较浅）
    lv_obj_add_style(satisfaction_label, &style_label, 0);
    // 对齐满意度标题：在容器底部中央，垂直偏移-10像素（从底部向上10像素）
    lv_obj_align(satisfaction_label, LV_ALIGN_BOTTOM_MID, 0, -10);
}

// ==============================
// 主界面显示函数
// ==============================

/**
 * @brief 显示主界面
 *
 *
 */
// 修改 create_parking_dashboard 函数，添加调试信息
void create_parking_dashboard(void)
{
    // printf("DEBUG: Entering create_parking_dashboard\n");

    // 初始化样式
    // printf("DEBUG: Before init_styles\n");
    init_styles();
    // printf("DEBUG: After init_styles\n");

    // 设置屏幕背景色
    // printf("DEBUG: Before setting background\n");
    lv_obj_set_style_bg_color(lv_scr_act(), COLOR_BG, 0);
    // printf("DEBUG: After setting background\n");

    // 逐个创建面板来定位问题
    // printf("DEBUG: Before create_overview_panel\n");
    create_overview_panel(lv_scr_act());
    // printf("DEBUG: After create_overview_panel\n");

    // printf("DEBUG: Before create_customer_behavior_panel\n");
    create_customer_behavior_panel(lv_scr_act());
    // printf("DEBUG: After create_customer_behavior_panel\n");

    // printf("DEBUG: Before create_peak_hours_panel_compact\n");
    create_peak_hours_panel_compact(lv_scr_act());
    // printf("DEBUG: After create_peak_hours_panel_compact\n");

    // printf("DEBUG: Before create_license_plate_panel\n");
    create_license_plate_panel(lv_scr_act());
    // printf("DEBUG: After create_license_plate_panel\n");

    // printf("DEBUG: Before create_feedback_panel\n");
    create_feedback_panel(lv_scr_act());
    // printf("DEBUG: After create_feedback_panel\n");

    // printf("DEBUG: create_parking_dashboard completed successfully\n");
}